Java设计模式----观察者模式详解

【声明】

欢迎转载，但请保留文章原始出处→_→

生命壹号：http://www.cnblogs.com/smyhvae/

文章来源：http://www.cnblogs.com/smyhvae/p/3899208.html

 

【正文】

一、观察者模式的定义：

简单地说，观察者模式定义了一个一对多的依赖关系，让一个或多个观察者对象监听一个主题对象。这样一来，当被观察者状态发生改变时，需要通知相应的观察者，使这些观察者对象能够自动更新。例如：GUI中的事件处理机制采用的就是观察者模式。

 

二、观察者模式的实现：

• Subject（被观察的对象接口）:规定ConcreteSubject的统一接口 ; 每个Subject可以有多个Observer；

• ConcreteSubject（具体被观察对象）:维护对所有具体观察者的引用的列表 ；–状态发生变化时会发送通知给所有注册的观察者。

• Observer（观察者接口）:规定ConcreteObserver的统一接口；定义了一个update()方法，在被观察对象状态改变时会被调用。

• ConcreteObserver（具体观察者）:维护一个对ConcreteSubject的引用；特定状态与ConcreteSubject同步； 实现Observer接口，update()方法的作用：一旦检测到Subject有变动，就更新信息。

图表描述如下：

注：在被观察者类中需要有一个集合维护所有观察者。

 

三、举例说明：

【方案一】：自己定义接口或者类来实现观察者模式。

步骤如下：

（1）定义被观察者所具有的接口：

package com.vince.observer;
public interface Observable {
    //注册为一个观察者    
    public void registerObserver(Observer observer);
    
    //取消观察者    
    public void removeObserver(Observer observer);
    
    //通知所有观察者更新信息    
    public void notifyObservers();
}

（2）定义具体的被观察者：杯子

package com.vince.observer;
import java.util.Vector;

public class Cup implements Observable{
    //被观察者维护的一个观察者对象列表
    private Vector<Observer> vector = new Vector<Observer>();
    private float price;
    
    public Cup(float price){
        this.price = price;
    }
    
    public float getPrice() {
        return price;
    }
    public void setPrice(float price) {
        //修改价格时，通知所有观察者
        this.price = price;
        notifyObservers();
    }
    @Override
    public void registerObserver(Observer observer) {
        //注册观察者
        vector.add(observer);
    }
    @Override
    public void removeObserver(Observer observer) {
        //取消观察者
        vector.remove(observer);
    }
    @Override
    public void notifyObservers() {
        //实现通知所有的观察者对象
        for (Observer observer:vector) {
            observer.update(price);
        }
    }
}

（3）定义观察者所具有的共同的接口：（更新数据最终当然是在观察者那里进行啦）

package com.vince.observer;

public interface Observer {
    public void update(float price);
}

（4）定义具体的观察者对象：

package com.vince.observer;
public class Person implements Observer{
    private String name;
    public Person(String name){
        this.name = name;
    }
    @Override
    public void update(float price) {
        System.out.println(name+"关注的杯子的价格已更新为："+price);
    }
}

（5）测试：

package com.vince.observer;
public class Test {
    public static void main(String[] args) {
        //创建一个被观察者对象
        Cup doll  = new Cup(3000);
        //创建两个观察者对象
        Person p1 = new Person("生命壹号");
        Person p2 = new Person("生命贰号");
        //注册成为一个观察者
        doll.registerObserver(p1);
        doll.registerObserver(p2);
        
        System.out.println("第一轮促销：");
        doll.setPrice(2698);// 价格变动
        System.out.println("第二轮促销：");
        doll.setPrice(2299);//
        System.out.println("第三轮促销：");
        doll.setPrice(1998);
        
        doll.removeObserver(p2);    //将生命二号移除
        System.out.println("第四轮促销：");
        doll.setPrice(1098);        
        
    }
}

运行后，显示结果如下：

 

 

【方案二】：直接调用JDK的API去实现。

步骤如下：

（1） 通过继承Observable类实现具体的被观察者对象：

package com.vince.observer2;
import java.util.Observable;

public class Cup extends Observable{
    private float price;
    
    public Cup(float price){
        this.price = price;
    }
    public float getPrice() {
        return price;
    }
    public void setPrice(float price) {
        this.price = price;
        this.setChanged();//通知，数据已改变
        this.notifyObservers();
    }
    
    
}

（2）通过实现java.util.Observer接口实现具体的观察者对象：

package com.vince.observer2;
import java.util.Observable;
import java.util.Observer;

public class Person implements Observer{
    private String name;
    public Person(String name){
        this.name = name;
    }
    @Override
    public void update(Observable o, Object arg) {
        if(o instanceof Cup){
            Cup cup = (Cup)o;
            System.out.println(name+"关注的杯子价格已更新为："+cup.getPrice());
        }
    }
}

（3）测试：

package com.vince.observer2;
public class Test {
    public static void main(String[] args) {
        Cup cup = new Cup(3000);
        Person p1 = new Person("生命壹号");
        Person p2 = new Person("生命贰号");
        cup.addObserver(p1);
        cup.addObserver(p2);
        System.out.println("第一轮促销");
        cup.setPrice(2988);
        System.out.println("第二轮促销");
        cup.setPrice(2698);
        
        cup.deleteObserver(p2);
        System.out.println("第三轮促销");
        cup.setPrice(1998);
    }
}

运行后，结果如下：

【工程文件】

链接：http://pan.baidu.com/s/1c03rLFM

密码：hois

 

四、总结：（观察者模式的作用）

• 观察者模式在被观察者和观察者之间建立一个抽象的耦合。被观察者角色所知道的只是一个具体观察者列表。

        由于被观察者和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。如果被观察者和观察者都被扔到一起，那么这个对象必然跨越抽象化和具体化层次。

• 观察者模式支持广播通讯。被观察者会向所有的登记过的观察者发出通知。

推荐学习链接：http://blog.csdn.net/crave_shy/article/details/21235855

 

 

我的公众号

想学习代码之外的软技能？不妨关注我的微信公众号：生命团队（id：vitateam）。

扫一扫，你将发现另一个全新的世界，而这将是一场美丽的意外：